Danny Amor's Online Library/Danny Amor's Online Library - Volume 1.iso/html/faqs/faq/objective-c/classes

Text File | 1995-07-25 | 37.1 KB | 918 lines

Subject: comp.lang.objective-c FAQ, part 2/3: ClassWare Listing
Newsgroups: comp.lang.objective-c,comp.answers,news.answers
From: [e-mail] (Tiggr)
Date: 17 Nov 1994 17:00:06 GMT

Archive-name: Objective-C/classes
Version: $Id: classes,v 2.15 1994/11/06 10:59:54 tiggr Exp $



                Objective-C

                 ClassWare Listing



This is the second of three FAQ postings for comp.lang.objective-c.  This
posting lists available kits and classes, to aid the reader in answering the
question `to re-use or to re-invent?'.  In order to keep this list up to date
and as interesting and diverse as possible, send your additions, deletions
and suggestions to [e-mail].

The available classes and kits are categorized as follows:

    Stepstone    Stepstone libraries,
            for use with Stepstone's environment
    NeXT        NeXT kits, for use with NEXTSTEP
    FSF        FSF maintained/released classes
            for use with GNU CC
    Third Party    commercial classes
    GPL        classes released under the GPL
    Public Domain    public domain classes---no GPL


Stepstone

    Bundled with the compiler is ICpak 101 Foundation Class Library.  This
    library provides twenty classes and more than three hundred methods
    including such things as Collections (OrdCltn, Stack, Set, Dictionary,
    SortCltn), Arrays (IdArray, IntArray), String, Sequences, Automatic
    Object I/O (ASCII Filer), etc.

    The ICpak 201 Graphical User Interface library is used to build iconic
    multi window user interfaces for workstation applications.  The library
    consists of 58 classes and over 1,100 methods.  Classes include such
    things as Controllers, Menu's, Menu Items, Icons, Windows(StdLayer),
    Timers, Buttons, Text, etc, etc.  ICpak 201 is ported to X Windows,
    OpenWindows, Motif and SunView and provides a consistent user interface/
    look-and-feel between all platforms.

    Contact

    The Stepstone Corporation
    75 Glen Road
    Sandy Hook, CT 06482
    tel: [phone]
    fax: [phone]
    telex: 506127

NeXT

    Common Classes

    Several classes provided with NeXTSTEP do not belong to a specific
    kit: Object (core of the runtime system, root of the general class
    hierarchy), Storage, List (an abstract array), HashTable (to store
    (key, object) associations), StreamTable (to write data to streams)
    and NXStringTable (to store (key, string) associations).

    Application Kit

    The Application Kit defines a set of Objective-C classes and
    protocols, C functions, and assorted constants and data types that
    are used by virtually every NeXTSTEP application.  The pith of the
    Kit are the tools it provides for implementing a graphical,
    event-driven user interface:

        The Application Kit provides classes---most notably Window and
        View---that make drawing on the screen exquisitely succinct.
        Much of the unromantic work that's involved in
        drawing---communicating with hardware devices and screen
        buffers, clearing areas of the screen before drawing,
        coordinating overlapping drawing areas---is taken care of for
        you, letting you concentrate on the much more gratifying task of
        supplying code that simply draws.  And even this task is
        assisted by many of the other classes and a number of C
        functions that provide drawing code for you.

        The Application Kit makes event handling extremely simple.  The
        Responder class, from which many of the Kit's classes inherit,
        defines a mechanism by which the user's actions are passed to
        the objects in your application that can best respond to them.
        The Application class, which inherits from Responder,
        establishes the low-level connections that makes this system
        possible.  It provides methods that inform your application of
        watershed events, such as when the user makes the application
        active and inactive, and when the user logs out or turns off the
        computer.

    By using these tools, you bless your application with a look and
    feel that's similar to other applications, making it easier for the
    user to recognize and use.

    (Introduction from the NeXTSTEP General Reference, "Application Kit"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    Database Kit

    The Database Kit provides a comprehensive set of tools, classes, and
    protocols for building applications that use a high-level
    entity-relationship model to manipulate database servers such as
    those provided by Oracle or Sybase.  The kit provides services that
    include:

        Communication with client-server databases.

        Modeling properties (attributes and relationships) of each
        database.

        Record management and buffering.

        Data flow between record managers and the application user
        interface.

        User interface objects for display and editing.

    (Introduction from the NeXTSTEP General Reference, "Database Kit"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    Distributed Objects

    The Distributed Objects system provides a relatively simple way for
    applications to communicate with one another by allowing them to
    share Objective-C objects, even amongst applications running on
    different machines across a network.  They are useful for
    implementing client-server and cooperative applications.  The
    Distributed Objects system subsumes the network aspects of typical
    remote procedure call (RPC) programming, and allow an application to
    send messages to remote objects using ordinary Objective-C syntax.

    The Distributed Objects system takes the form of two classes,
    NXConnection and NXProxy.  NXConnection objects are primarily
    bookkeepers that manage resources passed between applications.
    NXProxy objects are local objects that represent remote objects.
    When a remote object is passed to your application, it is passed in
    the form of a proxy that stands in for the remote object; messages
    to the proxy are forwarded to the remote object, so for most intents
    and purposes the proxy can be treated as though it were the object
    itself.  Note that direct access to instance variables of the remote
    object isn't available through the proxy.

    (Introduction from the NeXTSTEP General Reference, "Distributed Objects"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    Indexing Kit

    The Indexing Kit is a set of programmatic tools for managing data,
    especially the large amounts of data characteristic of information
    intensive applications.  Much as the Application Kit provides a
    framework for a graphical interface, the Indexing Kit provides a
    framework for data management.

    The Indexing Kit supplies facilities for building custom databases
    and for searching the UNIX file system.  Key benefits include
    guaranteed data integrity, excellent performance, thread-safe
    operation, tight integration with the NeXTSTEP programming
    environment, and the ability to efficiently store and retrieve
    Objective-C objects and unstructured data like text, sound, and
    images.

    The Indexing Kit consists of:

        A transaction-oriented foundation for storing and retrieving
        persistent data, using virtual memory mapping for efficient
        random access to parts of a file without reading or writing the
        entire file. Transactions guarantee data integrity on persistent
        storage media, and are also used to manage concurrent access to
        shared data.

        Fast sequential and associative access to stored data.
        Associative access is untyped, in that the programmer defines
        the data types of keys and their ordering by means of a
        comparison function or a format string.

        A simple data management capability based on the Objective-C
        run-time system.  Records can be moved efficiently between
        working memory and the storage substrate in the form of
        Objective-C objects.  Multiple indexes can be built over
        programmer-defined attributes, so that records can be ordered
        and retrieved by the values of their indexed attributes.

        A general query processing facility, including a declarative
        query language and its interpreter.  Queries can be applied to
        individual objects, to collections of objects, or to the
        attribute/value lists produced by Indexing Kit's customizable
        text processing tools.

        High-level file system searching facilities based on the
        supporting layers described above, including fast literal
        searching of file contents.

    (Introduction from the NeXTSTEP General Reference, "Indexing Kit"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    Mach Kit

    The Mach Kit provides an object-oriented interface to some of the
    features of the Mach operating system.  At this time, it is most
    useful to applications that make use of the Distributed Objects
    system, since these applications rely upon Mach's message sending
    abilities to transport objects, ports, and data between processes.
    The Mach Kit may also be useful for drivers and multi threaded
    applications.  The Mach Kit provides several classes and protocols,
    listed below.

    (Introduction from the NeXTSTEP General Reference, "Mach Kit"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    NetInfo Kit

    The NetInfo Kit is a collection of classes and a single function
    used to provide a connection to and interface with NetInfo domains.
    The NetInfo Kit provides classes for basic interface with a domain
    as well as specialized panels.

    (Introduction from the NeXTSTEP General Reference, "NetInfo Kit"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    3D Kit

    The 3D Graphics Kit enables NeXTSTEP applications to model and
    render 3-dimensional scenes.  Much as the Application Kit's 2D
    graphics capabilities are based on the Display PostScript
    interpreter, the 3D Kit's capabilities are based on the Interactive
    RenderMan renderer.  There are both similarities and differences in
    the inner workings of the two implementations.

    One similarity is that both are implemented with a client-server
    model, in which client applications send drawing code to the Window
    Server, which does the actual drawing.  Another similarity is that
    N3DCamera---the 3D Kit's View---generates all drawing code, both 2D
    and 3D, when its drawSelf: method is invoked.  This keeps the
    Application Kit's display mechanism intact for both PostScript and
    RenderMan drawing.

    One difference in the implementations is in the code generated for
    drawing. For 2D drawing, a View sends PostScript code to the Window
    Server's Display PostScript interpreter.  For 3D drawing, a View
    sends RenderMan Interface Bytestream (RIB) code to the Window
    Server's Interactive RenderMan renderer.

    (Introduction from the NeXTSTEP General Reference, "3D Graphics Kit"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    Sound Kit

    The Sound Kit is designed to provide both low- and high-level access
    to sound hardware on workstations running NeXTSTEP, including
    support for a wide variety of sound formats, real-time mixing and
    compression.  The Sound Kit consists of five general categories of
    objects:

        Sound Device Objects

        Sound Device objects, like NXSoundIn and NXSoundOut,
        wrap the low-level hardware and sound drivers into
        simple, extensible packages.

        Sound Streams

        Sound Stream objects, like NXPlayStream or NXRecordStream,
        allow the sound output of many simultaneous programs to be
        mixed, scaled, and processed before being sent out the Sound
        objects.

        The Sound Object

        The Sound object is NeXTSTEP's fundamental sound data
        storage and playback/recording facility.

        The SoundView Object

        NeXTSTEP's Sound View is a graphical display of sound data
        that interacts well with the NeXTSTEP GUI.

        The Sound Meter Object

        The Sound Meter displays the current running amplitude of a
        playing or recording sound (in mono), much like volume
        meters on amplifiers or tape decks.

    In addition to this library, NeXT provides two sets of sound driver
    and sound access functions.

    NXLiveVideoView

    The NXLiveVideoView class provides API for interactive display of
    live video on the screen of a NeXTdimension Computer.  The
    NXLiveVideoView class specification provides a complete discussion
    of the NeXTdimension Computer's video capabilities and the API
    provided by NXLiveVideoView.

    (Introduction from the NeXTSTEP General Reference, "Video"
    reprinted with permission.  Copyright (c) 1993 NeXT Computer, Inc.
    All rights reserved.)

    Applications

    There are several classes which solely exist to enable the
    programmer to add functionality to specific existing NEXTSTEP
    applications:

        IBPalette, IBInspector

        These classes allow developers to expand the functionality
        of the Interface Builder application, creating their own
        palettes of objects that can be dragged into an interface,
        and inspectors to set and view the attributes of those
        objects.

        Layout

        This class allows developers to add their own modules to the
        Preferences application.

        WMInspector

        This class allows developers to add their own file contents
        inspectors to the Workspace Manager application.

    Other

    Before NeXTSTEP 3.0, MusicKit was distributed as part of NEXTSTEP.
    MusicKit is now maintained and made available by CCRMA (see the
    entry under `Public Domain Kits').  Also until the advent of
    NeXTSTEP 3.0, PhoneKit was part of NeXTSTEP.  PhoneKit classes
    provided easy to ISDN connections.

    Contact

    NeXT Computer, Inc.
    900 Chesapeake Drive
    Redwood City, CA 94063
    tel: [phone] NEXT
    fax: [phone]
    email: [e-mail]

FSF

    Object

    Object is the root class which comes as part of the Objective-C
    runtime library provided with the GNU CC compiler.

    GNU Objective-C Class Library

    The GNU Objective C Class Library (libobjects) is a library of
    general-purpose, non-graphical Objective C objects written by
    R. Andrew McCallum.  What `libg++' is to GNU's C++, `libobjects' is
    to GNU's Objective C.

    The library features collection objects for maintaining groups of
    objects and C types, streams for I/O to various destinations, coders
    for formating objects and C types to byte streams, ports for network
    packet transmission, distributed objects (remote object messaging),
    pseudo-random number generators, and time handling facilities.

    * The heirarchy of collection objects are similar in spirit to
      Smalltalk's collections.  A deep inheritance heirarchy provides
      good uniformity of method names across different collection
      classes.  All collections can hold simple C types (such as int's
      and floats) as well as Objects.  The collection classes include
      simple collections (Set, Bag), collections with contents
      accessible by unordered keys (Dictionary, MappedCollector),
      collections with ordered contents (Array, LinkedList, Stack,
      Queue, Heap, BinaryTree, RBTree, SplayTree, GapArray).  There is
      also a DelegatePool object that can forward messages it receives
      to an arbitrary number of delegate objects.

    * Stream objects provide a consistent interface for reading and
      writing bytes.  `StdioStream' objects work with files, file
      descriptors, FILE pointers and pipes to/from
      executables. `MemoryStream' objects work with memory buffers that
      grow automatically as needed.  For all Stream objects there are
      methods for writing/reading arbitrary n-length buffers,
      newline-terminated lines, and printf-style strings.

    * Coders provide a formatted way of writing to Streams.  After a
      coder is initialized with a stream, the coder can encode/decode
      Objective C objects and C types in an architecture-independent
      way.  The currently available concrete coder classes are
      `BinaryCoder', for reading and writing a compact stream of
      illegible bytes, and `TextCoder', for reading and writing
      human-readable structured textual representation (which you can
      also process with `perl', `awk', or whatever scripting language
      you like).

      Coders and streams can be mixed and matched so that programmers can
      choose the destination and the format separately.

    * The distributed object support classes are `Connection', `Proxy',
      `ConnectedCoder', `Port' and `SocketPort'.  This version of the
      distributed objects only works with sockets.  A Mach port back-end
      should be on the way.

      [NOTE: The GNU distributed object facilities have the same
      ease-of-use as NeXT's; be warned, however, that they are not
      compatible with each other.  They have different class
      heirarchies, different instance variables, different method names,
      different implementation strategies and different network message
      formats.  You cannot communicate with a NeXT NXConnection using a
      GNU Connection.  NXConnection creates NXProxy objects for local
      objects as well as remote objects; GNU Connection doesn't need and
      doesn't create proxies for local objects.  NXProxy asks it's
      remote target for the method encoding types and caches the
      results; GNU Proxy gets the types directly from the local GNU
      "typed selector" mechanism and has no need for querying the remote
      target or caching encoding types.  The NXProxy for the remote root
      object always has name 0 and, once set, you cannot change the root
      object of a NXConnection; the GNU Proxy for the remote root object
      has a target address value just like all other Proxy's, and you
      can change the root object as many times as you like.  See the
      "lacking-capabilities" list below for a partial list of things
      that NXConnection can do that GNU Connection cannot.]

      Here is a partial list of what the current distributed objects
      system can do:

          * It can pass and return all simple C types, including char*, float
            and double, both by value and by reference.
          * It can pass structures by value and by reference, return
            structures by reference.  The structures can contain arrays.
          * It obeys all the type qualifiers: oneway, in, out, inout, const.
          * It can pass and return objects, either bycopy or with proxies.
            An object encoded multiple times in a single message is properly
            decoded on the other side.
          * Proxies to remote objects are automatically created as they are
            returned.  Proxies passed back where they came from are decoded
            as the correct local object.
          * It can wait for an incoming message and timeout after a
            specified period.
          * A server can handle multiple clients.
          * The server will ask its delegate before making new connections.
          * The server can make call-back requests of the client, and keep
            it all straight even when the server has multiple clients.
          * A client will automatically form a connection to another client
            if an object from the other client is vended to it. (i.e. Always
            make a direct connection rather than forwarding messages twice,
            once into the server, from there out to the other client.)
          * The server will clean up its connection to a client if the client
            says goodbye (i.e. if the client connection is freed).
          * When the connection is being freed it will send a invalidation
            notification message to those objects that have registered for
            such notification.
          * Servers and clients can be on different machines of different
            architectures; byte-order and all other architecture-dependent
            nits are taken care of for you.  You can have SPARC, i386, m68k,
            and MIPS machines all distributed-object'ing away together in
            one big web of client-server connections!

      Here is a partial list of what the current distributed objects
      system does *not* do:

          * Run multi-threaded.
          * Detect port deaths (due to remote application crash, for example)
            and do something graceful.
          * Send exceptions in the server back to the client.
          * Return structures by value.
          * Use Mach ports, pass Mach ports, pass Mach virtual memory.
          * Send messages more reliably than UDP.  It does detect reply
            timeouts and message-out-of-order conditions, but it's reaction
            is simply to abort.
          * Claim to be thoroughly tested.

    Getting It, and Compiling It

        The library is available by anonymous ftp at URL:
         ftp://prep.ai.mit.edu/pub/gnu/libobjects-0.1.0.tar.gz
        Since `prep' is heavily loaded, you are
        encouraged to use GNU mirror sites.

        The most recent (not necessarily tested) snapshots of the
        library will be placed at `ftp://alpha.gnu.ai.mit.edu/gnu'.

        The library requires gcc 2.6.1 or higher.  The library does not
        work with the NEXTSTEP 3.2 compiler because that version of
        NeXT's cc cannot handle nested functions.  Until a later release
        from NeXT, NEXTSTEP users will have to install gcc.  Also,
        temporarily, the library does not work with the NeXT Objective C
        runtime library.

        The library has been successfully compiled and tested with the
        following configurations: mips-sgi-irix5.2 sparc-sun-sunos4.1.3
        m68k-next-nextstep3.0.

        Some previous snapshots of the library worked with these
        configurations, but they haven't been tested recently:
        i386-unknown-linux i386-sun-solaris2.4 i386-unknown-sysv4.0
        sparc-sun-solaris2.3.

        It is known not to work with: alpha-dec-osf.

    Now and Future

        The current version is 0.1; the low number indicates that the
        library is still in flux.  A version coming soon will include
        String objects and better allocation/dealocation conventions.

    GNUStep, NEXTSTEP and OpenStep

        The libobjects library already contains many of the "Common
        Classes" in NeXTSTEP: List, HashTable, Storage, NXStringTable.
        In the future it will also contain classes compatible with the
        OpenStep Foundation Kit. Progress is already being made on this
        front.

    Contact

        Andrew McCallum
        [e-mail]

    Contact

    Free Software Foundation
    675 Massachusetts Avenue
    Cambridge, MA  02139
    [phone]


Third Party Kits

    Hot Technologies

    BARCODEKIT

        BarCodeKit is a comprehensive collection of object palettes for
        creating international standard bar codes.  BarCodeKit allows
        both developers and organizations to quickly add bar coding to
        custom NEXTSTEP applications.  By combining the power of object
        orientation and PostScript into a comprehensive library of bar
        code symbologies, BarCodeKit represents the state of the art in
        bar code technology.  Developers can seamlessly add bar coding to
        an existing application in a matter of minutes by using any of
        the 35 pretested and reusable objects in the BarCodeKit library
        of palettes.  Previously, adding bar coding to an application
        meant weeks or months of development, incompatibility with
        different bar code readers and the use of costly proprietary bar
        code printers.

        The BarCodeKit features a full range of bar code symbologies
        including Code 3 of 9, Code 39 Extended, UPC-A, UPC-E, HRI, NDC,
        EAN-8, EAN-13, JAN-8, JAN-13, ISBN, ISSN, SICI, SISAC, POSTNET,
        ABC, FIM, BRM, Interleaved Two of Five, MSI, Codabar, Code 11,
        Code 93, Code 128, Code 16K and Code 49.  It complies to
        international, national, military and commercial bar coding
        standards including EAN, JAN, CEN, ANSI, MIL, USS and HIBCC.
        Furthermore, it provides developers with flexibility; bar codes
        created using the kit can be scaled and rotated to fit a
        specific area on a label or document and saved in EPS, EPSI (EPS
        with interchange bitmap preview for non Display PostScript
        computers), or TIFF formats.  BarCodeKit is an excellent
        complement to NEXTSTEP's Application Kit and Database Kit It was
        nominated for a Best of Breed Award by the editors of NeXTWORLD
        Magazine.

    SERIALPORTKIT

        SerialPortKit is a fundamental class library and palette that
        makes communication with serial peripherals easy to add into
        your custom NEXTSTEP applications without any of the drawbacks
        of other solutions.  You can use SerialPortKit to communicate
        with a variety of serial peripherals such as modems, printers,
        terminals, audio/video equipment, bar code readers, magnetic
        stripe readers, controllers and data acquisition devices.  The
        SerialPortKit contains a single SerialPort class which
        interfaces to our SerialPortServer. Additional classes for
        specific peripherals are available in our SerialPeripheralsKit
        or through our consulting service.

        You can easily incorporate the SerialPortKit into your custom
        applications due to its professionally designed and truly
        object-oriented programming interface. The included Interface
        Builder palette, source code examples, on-line indexed reference
        manuals and tutorial further removes the tedious task of
        traditional serial port programming.  Requires SerialPortServer
        or SerialPortServer Lite which are available also from Hot
        Technologies.

    Contact

        Hot Technologies
        75 Cambridge Parkway, Suite E-504
        Cambridge, MA 02142-1238 USA
        tel: + 1 617 252 0088
        fax: + 1 617 876 8901
        email: [e-mail] (NeXTmail)

    Berkeley Productivity Group

    BPG BLOCKS

        BPG BLOCKS is an open extensible manufacturing framework which
        supports a variety of applications including factory definition,
        real-time tracking, real-time scheduling, short-term planning,
        shift scheduling, production planning and capacity analysis.
        BPG BLOCKS creates a virtual reality which represents the real
        factory including the people, machines, material, processes,
        their dynamics and interactions.  BPG BLOCKS is based on an easy
        to understand design where every software object represents
        either a real-world entity, or an important concept in the
        manufacturing domain.  BPG BLOCKS' object-oriented manufacturing
        model mirrors the real world, captures numerous manufacturing
        details accurately, supports commonly used abstractions, and
        allows decisions to be made based on aggregate information.  BPG
        BLOCKS forms the basis for building custom applications which
        meet the unique needs of your particular manufacturing
        facility.

    Objective-C Views

        Objective-C Views is a user interface class library for
        Microsoft Windows.

    Contact

        Christopher Lozinski
            BPG
            35032 Maidstone Court
            Newark, CA 94560
            tel: [phone]
            fax: [phone]
            email: [e-mail]


    M. Onyschuk and Associates Inc.

    OBJECT:Math

        OBJECT:Math is a comprehensive set of tools and 23 Objective-C
        classes used to add extensible math and string handling to your
        custom and commercial applications:

        Compiler---The OBJECT:Math Compiler converts math and string
        expressions (as might be typed into a spreadsheet cell,
        plotting package, etc.) into Objective-C objects.

        Unbundler---The OBJECT:Math Unbundler object allows
        end-users to extend their OBJECT:Math applications with
        custom-built or third-party OBJECT:Math function bundles.

        User Interface Objects---OBJECT:Math comes complete with a
        Lotus Improv style function picker, a variable editor, and
        objects used to display OBJECT:Math expression trees and
        other tree structures.

        As product sources are available the product may even be of
        interest to non-NeXT Objective-C programmers.

    Contact

        Mark Onyschuk
        M. Onyschuk and Associates Inc.
        tel: [phone]
        email: [e-mail]


    Stream Technologies Inc.

    Store

        Store is an Object Oriented User Level Virtual File System.
        It is described extensively in `Store - Object Oriented Virtual
        File System' by Timo Lehtinen, which is available by anonymous
        FTP from ftp.sti.fi:/pub/sti/doc/papers/store.ps.

    Contact

        Stream Technologies Inc.
        Valkj\"arventie 2
        SF-02130 Espoo
        Finland
        tel: [phone]
        fax: [phone]
        email: [e-mail]


GPL Kits

   objcX

    An alpha version of an GNU Objective-C class library for X/Motif
    Windows is available via anonymous ftp from

        ftp.slac.stanford.edu:pub/sources/objcX-0.82.tar.gz.

    For lack of a good witty name, the library is called objcX.

    The library requires the List class from the Collection Library for
    GNU Objective-C (libcoll).

    Because we built this library to support porting NeXTSTEP
    applications to X/Motif and because our GUI programming experience
    has been with NeXTSTEP, this class library has a strongly
    resemblance to NeXT's AppKit.  However, it is only a Objective-C
    wrapper to Motif widgets and does not support Display PostScript,
    rich text, pasteboard, drag and drop, services or many other things
    associated with the NeXTSTEP environment that are not available
    under X windows.

    From version 0.8, the nib translator is part of the objcX
    distribution, as well as some examples of using objcX.

    These announcements are also a call for help.  The library and the
    translator program could use much more work in two areas...

     - first the library could be flushed out with more features to
       support larger applications

     - second, I would like to contribute the library to the GNU
       project. But it is based on Motif widgets which is not free
       software.  Thus, work is needed to replace Motif widgets with
       widgets based on free software.

    To stay informed, join the mailing list [e-mail] by
    sending a subscription email to [e-mail].

    Contact

        Paul F. Kunz    [e-mail] (NeXT mail ok)
        Stanford Linear Accelerator Center, Stanford University
        Voice: [phone]   (NeXT) Fax: [phone]


    Tcl/Objective-C Interface Library

    A library of Objective-C objects and support functions for
    communication between Objective-C and Tcl/Tk.  From Tcl you can send
    messages to Objective-C objects and get textual representations of
    what's returned.  Thus it provides a way to interactively type
    messages and see the results, all inside the rich structure of the
    Tcl scripting language---almost an Objective-C interpreter.  The
    library also provides an Objective-C object that will forward all of
    its messages to the Tcl interpreter in textual format.

    The library does NOT provide:
      * Handling arguments of non-atomic C types.
      * Tk widgets based NeXTSTEP AppKit objects.
      * The ability to create new Objective-C classes
        or methods from Tcl.

    The library is available by anonymous ftp at
        ftp.cs.rochester.edu:pub/libcoll/libtclobjc-1.0.tar.gz

    The library requires gcc (2.5.8 or higher) or NeXT's cc and tcl-7.3.
    If you have tk-3.6, the library can be configured to use it.  If you
    have libreadline, the library can be configured to use it.  Gcc and
    libreadline are available at any of the GNU archive sites; tcl and
    tk are available at ftp.cs.berkeley.edu.

    Contact

        R. Andrew McCallum            ARPA: [e-mail]
        Computer Science Department   UUCP: uunet!cs.rochester.edu!mccallum
        University of Rochester       VOX: [phone]
        Rochester, NY  14627-0226     FEET: CSB  Rm. 625

    Tiggr's Objective-C Library

    Tiggr's Objective-C Library, or tobjc for short, is a basic
    Objective-C library, whose functionality is based on Lisp.

    tobjc provides the following classes: LispObject, LispVector,
    Cons, Double, Integer, String, AVLTree, THashTable, StringTable,
    Trie, Lex, LexC and LexDFG.  Furthermore, tobjc includes a
    program to extract documentation from Objective-C source files.

    All classes are a subclass of LispObject.  The LispObject class
    provides its allocation routines and garbage collection (through
    class abstraction) to its subclasses.

    tobjc was undergoing continuous development.  Test releases can
    be obtained by anonymous FTP to `ftp.es.ele.tue.nl' as
    `/pub/tiggr/tobjc-x.xx.tar.gz', where `x.xx' is some version
    indication.  It is by no means finished yet, but certainly
    useful (I have used it for developing a VHDL->ASCIS DFG compiler),
    or at least interesting.

    I have been working on a new version which can handle messages sent
    to nil by setting something called the `objc_nil_class'.  This means
    that that particular class can receive messages while `self == nil',
    i.e. it is possible to make `[nil listp]' return YES.  If you're
    interested, mail me for a copy (it is not good enough to be released
    through ftp yet).

    Contact

        Pieter J. `Tiggr' Schoenmakers
        email: [e-mail]
        tel: [phone]
        fax: [phone]


Public Domain Kits

    Various authors

    MiscKit

        The MiscKit is a collection of over sixty objects which extend
        the NEXTSTEP Objective-C development environment in various
        ways.  It includes palletized subclasses of AppKit controls,
        foundation objects, and a variety of useful special purpose
        objects.

        Objects include strings, basic data structures, and kits for
        building swapping views and inspectors.  There are also
        frameworks for building Info menus and a generic document
        handling architecture.  Palettized objects include a logarithmic
        and circular sliders, a tri-state button, a combined Slider and
        TextField, and a read-only NXColorWell.  There are other
        objects, functions, and useful macros in the kit as well.

        Documentation, examples, tutorials, and complete source code are
        distributed with the MiscKit.  The kit itself is the product of
        over 25 Usenet personalities and is available free of cost for
        use in any project.  The only restriction is that you
        acknowledge use of the kit in your project.

        Misckit 1.2.6 can be obtained from the usual NEXTSTEP ftp sites:

        cs.orst.edu:/pub/next/sources/objects/MiscKit1.2.6.tar.gz
        sonata.cc.purdue.edu:/pub/next/submissions/MiscKit1.2.6.tar.gz
        ftp.et.byu.edu:/pub/next/misckit/MiscKit1.2.6.tar.gz
            ftp.informatik.uni-muenchen.de:/pub/comp/platforms/next/
                Developer/objc/misckit/MiscKit1.2.6.s.tar.gz

    Contact

        For more information or to be placed on the MiscKit discussion
        list, contact the kit administrator, Don Yacktman, by sending
        e-mail to [e-mail].

    CCRMA

    MusicKit

        The Music Kit provides tools for designing music
        applications. These tools address three topics: music
        representation, performance, and synthesis (digital sound
        generation and processing).  The Objective-C classes defined in
        the Music Kit fall neatly into these three areas.

        The design goal of the Music Kit is to combine the interactive
        gestural control of MIDI with the precise timbral control of
        MUSIC 5-type systems in an extensible, object-oriented
        environment. To this end, the Music Kit is capable of fully
        representing MIDI.  The Music Kit accepts MIDI in and can send
        MIDI out through the two serial ports at the back of the
        computer. Nonetheless, the Music Kit isn't limited by the MIDI
        specification; for example, its resolution of frequency and
        amplitude is much finer than MIDI's highly quantized values.

        The Music Kit generates sounds by sending synthesis instructions
        to the DSP.  The generality of the synthesis software far
        surpasses that of commercial synthesizers.  While most
        synthesizers employ only one type of synthesis-the Yamaha DX-7
        uses only frequency modulation, for example-the Music Kit can
        implement virtually any sound synthesis strategy.  And since the
        synthesis engine (the DSP) and the control stream are brought
        together in a single high-performance computer, the Music Kit
        makes possible an unprecedented level of expressive control.
        (from Documentation/MusicKit+DSP/General/SoundMusicDSP.rtfd)

        MusicKit used to be supplied by NeXT as part of NeXTSTEP (pre
        3.0).  It is now maintained by CCRMA and available by FTP from
        ccrma-ftp.stanford.edu.  There are two packages:

        pub/MusicKit_4.0.pkg.tar

            Class library, header files, documentation, programming
            examples, and a suite of applications (size = 9MB).

        pub/MusicKitSource_4.0.pkg.tar
            Source of the MusicKit class library (size = 7MB).

    Contact

        email: [e-mail]


ADMINISTRATIVIA

    The information in this file comes AS IS, WITHOUT ANY WARRANTY.  You may
    use the information contained in this file or distribute this file, as
    long as you do not modify it, make money out of it or take the credits.

    All trademarks appearing in this file are owned by their respective
    owner.  To increase the information content in this file, any indication
    to that effect is not present in the FAQ other than in this paragraph.

The first version of this FAQ was written by Bill Shirly, helped by the
feedback and information given to him by a lot of people.  The current
version is maintained by Tiggr, supported by feedback from Glen Diener,
Christopher Lozinski, Sean Luke and a lot of other people.  Mail your bug
reports, comments, suggestions and additions to [e-mail].

A World Wide Web hypertext version of this FAQ is maintained by Brian Harvey
([e-mail]) and can be found at:
    http://csld.ucr.edu/NeXTSTEP/objc_faq.html